JavaScript syntax
part 7/30 · 107.0 KB total
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
There is also a numeric separator, _ (the underscore), introduced in
ES2021:
// Note: Wikipedia syntax does not support numeric separators yet
1_000_000_000; // Used with big numbers
1_000_000.5; // Support with decimals
1_000e1_000; // Support with exponents
// Support with binary, octals and hex
0b0000_0000_0101_1011;
0o0001_3520_0237_1327;
0xFFFF_FFFF_FFFF_FFFE;
// But users cannot use them next to a non-digit number part, or at the
start or end
_12; // Variable is not defined (the underscore makes it a variable
identifier)
12_; // Syntax error (cannot be at the end of numbers)
12_.0; // Syntax error (does not make sense to put a separator next to
the decimal point)
12._0; // Syntax error
12e_6; // Syntax error (next to "e", a non-digit. Does not make sense to
put a separator at the start)
1000____0000; // Syntax error (next to "_", a non-digit. Only 1
separator at a time is allowed
obtained by two program expressions:
Infinity; // positive infinity (negative obtained with -Infinity for
instance)
NaN; // The Not-A-Number value, also returned as a failure in ...
// ... string-to-number conversions
Infinity and NaN are numbers:
typeof Infinity; // returns "number"
typeof NaN; // returns "number"
These three special values correspond and behave as the IEEE-754
describes them.
The Number constructor (used as a function), or a unary + or -, may be
used to perform explicit numeric conversion:
const myString = "123.456";
const myNumber1 = Number(myString);
const myNumber2 = +myString;
When used as a constructor, a numeric wrapper object is created (though
it is of little use):
const myNumericWrapper = new Number(123.456);
However, NaN is not equal to itself:
const nan = NaN;
console.log(NaN == NaN); // false
console.log(NaN === NaN); // false
console.log(NaN !== NaN); // true
console.log(nan !== nan); // true
// Users can use the isNaN methods to check for NaN
console.log(isNaN("converted to NaN")); // true
console.log(isNaN(NaN)); // true
console.log(Number.isNaN("not converted")); // false
console.log(Number.isNaN(NaN)); // true
BigInt
In JavaScript, regular numbers are represented with the IEEE 754
floating point type, meaning integers can only safely be stored if the
value falls between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER.
programmers to store integers too high or low to be represented with the
IEEE 754 format.cite-ref-bigint-mdn-11-0[11]
There are two ways to declare a BigInt value. An n can be appended to an
integer, or the BigInt function can be used:cite-ref-bigint-mdn-11-1[11]
const a = 12345n; // Creates a variable and stores a BigInt value of
12345
const b = BigInt(12345);
String